package sucre

import ve.org.src.constantes.LoginConstantes
import ve.org.src.constantes.EventoConstantes
import ve.org.src.util.DateUtils
import ve.org.src.utils.encryption.CryptoUtils
import ve.org.src.sesiones.ManejadorSesiones
import ve.org.src.sesiones.CacheSeguridad

class LoginService {

    boolean transactional = true
    def auditoriaService

    def validarUsuario(user,pass,address){
        def usuario = Usuario.findByLogin(user)
        if(usuario != null){
            println "usuario" + usuario
            println "LoginConstantes.PASSWORD_ACTIVO" + LoginConstantes.PASSWORD_ACTIVO
            def password = Password.find("from Password as p where p.usuario=:usuario and p.fechaFin is null and p.estado=:estado",[usuario:usuario,estado:LoginConstantes.PASSWORD_ACTIVO])
            if(password != null){
                if(password.clave.equals(CryptoUtils.codificarContrasenna(pass))){
                    //auditoriaService.registrarAuditoriaAccion(usuario,EventoConstantes.INICIO_SESION,address,'')
                    usuario.fechaUltimoAcceso = new Date()
                    //usuario = usuario.merge()
                    usuario.save()
                    
                    return [Usuario:usuario,Resultado:LoginConstantes.PASSWORD_VALIDO]
                }
                else{
                    //auditoriaService.registrarAuditoriaAccion(usuario,EventoConstantes.PASS_INVALIDO_INICIO_SESION,address,'')
                    return [Usuario:usuario,Resultado:LoginConstantes.PASSWORD_INVALIDO]
                }
            }
        }        
        return null
    }

    def validarAcceso2(user,accionMenu,controlador,accion){
        String msg=''

        if(user == null)
        return false
       
        def usuario = CacheSeguridad.getUsuario(user)
        if(usuario == null)
        return false
       
        if(DateUtils.isBeforeToday(usuario.fechaCaducidad))
        return false
       
        if(accionMenu == null || accionMenu.size()==0)
        return false

        def estatus = false
        for(AccionMenu action:accionMenu){
            if(action.controlador.equals(controlador) && action.accion.equals(accion)){
                estatus = true
                break
            }
        }
       
        if(estatus == false){
            println 'ACCESO DENEGADO '+controlador+' -> '+accion            
            //bloquearUsuario(usuario,LoginConstantes.ESTADO_USUARIO_BLOQUEADO_ACCESO_INDEBIDO)
            return false
        }

        return estatus
    }
    //metodo que devuelve el status de la sesion
    def validarAcceso(user,funcionesHabilitadas,controlador,accion,ip,regAuditoria,actualizarSesion){
        int estatus=0
        if(user == null){
            estatus=1
        }else{
            def usuario = CacheSeguridad.getUsuario(user)
            if(usuario==null){
                estatus=2
            }else if(DateUtils.isBeforeToday(usuario.fechaCaducidad)){
                estatus=3
            }else if(funcionesHabilitadas==null || funcionesHabilitadas.size()==0){
                estatus=4
            }else if(funcionesHabilitadas.get(controlador+accion)==null){
                estatus=5
                ManejadorSesiones.caducarSesion(user)
            }else if(ManejadorSesiones.verificarInactividad(user,actualizarSesion)){
                estatus=6
            }
        }
        
        if(estatus!=0){
            println 'ACCESO DENEGADO '+controlador+' -> '+accion+' ['+estatus+']'
            return false
        }else{
            println "Registrar auditoria"
            return true
        }
    }
    def validarAcceso(user,funcionesHabilitadas,controlador,accion,ip){
        validarAcceso(user,funcionesHabilitadas,controlador,accion,ip,true,true)
    }


    def cargarAccionesMenu(user) {
        def lista =[]

        def perfil = user.perfil
        if(perfil != null) {
            def acciones = perfil.acciones

            for(AccionMenu a:acciones){
                if(a.visible){
                    lista.add(a)
                }
            }
            lista.sort{it.orden}
            return lista
        }
        return null
    }
    def cargarFuncionesHabilitadas(accionesMenu){

        if(accionesMenu!=null && accionesMenu.size()>0){
            def ids=[]
            accionesMenu.each{
                ids.add(it.id)
            }
            def accionesHabilitadas=AccionMenuFuncion.createCriteria().list{
                'in'('idAccionMenu',ids)
                eq('habilitada',true)
            }
            def mapaAccionesHabilitadas=[:]
            accionesHabilitadas.each{
                mapaAccionesHabilitadas.put(it.controlador+it.accion,1)
            }
            return mapaAccionesHabilitadas
        }
        return null
    }

    def bloquearUsuario(usuario,motivo) {
        usuario.estado = motivo
        usuario = usuario.merge()
        if(!usuario.hasErrors() && usuario.save()){
            CacheSeguridad.setUsuario(usuario)
            return;
        }
        else
        usuario.errors.each{ println it }
    }


    def validarDirectivas(password) {
        def response=[:]
        def directivas=[]
        
        try{
            directivas=DirectivaPassword.createCriteria().list{
                eq('activa',true)
            }
            //consultan las directivas activas
        }catch(Exception e){
            // response.put('respuesta',CodigoDevolucionConstantes.ERROR_COMUNICACION_BASE_DATOS)
            return response
        }

        return true
    }

    def actualizarPassword(user,password,address) {
        def usuario = CacheSeguridad.getUsuario(user)

        def anterior = Password.find("from Password as p where p.usuario=:usuario and p.fechaFin is null and p.estado=:estado",[usuario:usuario,estado:LoginConstantes.PASSWORD_ACTIVO])
        def pass = new Password()
        pass.fechaCreacion = new Date()
        pass.fechaFin = null
        pass.estado = LoginConstantes.PASSWORD_ACTIVO
        pass.usuario = usuario
        pass.clave = CryptoUtils.codificarContrasenna(password)

        if(!pass.hasErrors() && pass.save()) {
            if(anterior){
                anterior.fechaFin = new Date()
                anterior.estado = LoginConstantes.PASSWORD_INACTIVO
                anterior.save()
            }
            
            usuario.fechaCaducidad = DateUtils.rollDays(LoginConstantes.DIAS_CADUCIDAD)
            usuario = usuario.merge()
            usuario.save()
            CacheSeguridad.setUsuario(usuario)
            //auditoriaService.registrarAuditoriaAccion(usuario,EventoConstantes.CAMBIO_PASSWORD,address,'')
            
            return true
        }
        return false
    }

    def asignarPassword(user,password,address) {
        def usuario = CacheSeguridad.getUsuario(user)
        def pass = new Password()
        pass.fechaCreacion = new Date()
        pass.fechaFin = null
        pass.estado = LoginConstantes.PASSWORD_ACTIVO
        pass.usuario = usuario
        pass.clave = CryptoUtils.codificarContrasenna(password)

        if(!pass.hasErrors() && pass.save()){
            usuario.fechaCaducidad = new Date()
            usuario = usuario.merge()
            usuario.save()
            CacheSeguridad.setUsuario(usuario)
            // auditoriaService.registrarAuditoriaAccion(usuario,EventoConstantes.ASIGNAR_PASSWORD,address,'')
            return true
        }else{
            println 'errores '
            println 'aaaaa '+pass.errors

        }
        return false
    }
    def nuevoPassword(user,passwordTextPlain){
        boolean cambioClave=true
        def password=new Password()
        password.fechaCreacion=new Date()
        password.fechaFin=null
        password.estado=LoginConstantes.PASSWORD_ACTIVO
        password.usuario=user
        password.clave = CryptoUtils.codificarContrasenna(passwordTextPlain)
        Password.withTransaction{status->
            def pass=Password.findAllByUsuario(user)
            println 'pass='+pass
            pass.each{p->
                p.estado=LoginConstantes.PASSWORD_INACTIVO
                p.save()
            }
            if(!password.save()){
                println password.errors
                status.setRollbackOnly()
                cambioClave=false
            }
        }
        return cambioClave
    }
    def cerrarSesion(user,address){
        //session.invalidate()
        return true
    }
    

}
